DSPI.c

Go to the documentation of this file.

#include "derivative.h"
#include "DSPI.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
const uint8_t cau8DSPIInstances[N_DSPI_INSTANCES * N_DSPI_PRESETS] =
{
  DSPI0C0, DSPI0C1, DSPI0C2, DSPI0C3, DSPI0C4, DSPI0C5, DSPI0C6, DSPI0C7,
  DSPI1C0, DSPI1C1, DSPI1C2, DSPI1C3, DSPI1C4, DSPI1C5, DSPI1C6, DSPI1C7,
  DSPI2C0, DSPI2C1, DSPI2C2, DSPI2C3, DSPI2C4, DSPI2C5, DSPI2C6, DSPI2C7,
  DSPI3C0, DSPI3C1, DSPI3C2, DSPI3C3, DSPI3C4, DSPI3C5, DSPI3C6, DSPI3C7 };

const DSPI_t catDSPIInstances[N_DSPI_INSTANCES] =
{
  &DSPI_0, &DSPI_1, &DSPI_2, &DSPI_3 };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
vuint8_t gau8DSPIBuffSize[N_DSPI_INSTANCES];
vuint8_t gau8DSPIWordsRx[N_DSPI_INSTANCES];
vuint8_t gau8DSPITransferSize[N_DSPI_INSTANCES];
vuint8_t gau8DSPITxFIFOIsEnabled[N_DSPI_INSTANCES];
vuint8_t gau8DSPIRxFIFOIsEnabled[N_DSPI_INSTANCES];
vuint16_t* gpu16DSPITxBuffer[N_DSPI_INSTANCES];
vuint16_t* gpu16DSPIRxBuffer[N_DSPI_INSTANCES];
vuint8_t* gpu8DSPITxBuffer[N_DSPI_INSTANCES];
vuint8_t* gpu8DSPIRxBuffer[N_DSPI_INSTANCES];
/*
 ******************************************************************************
 * u8fnDSPITranscieve
 ******************************************************************************
 */
uint8_t u8fnDSPITranscieve(const uint8_t u8MyInstanceWCTAR,
                           const uint8_t u8CSEnable, uint16_t* pu16DSPITx,
                           uint16_t* pu16DSPIRx, const uint8_t u8Size)
{
  /* Local variables */
  uint8_t u8Status;
  DSPI_t ptMyDSPI;
  DSPIInstance_t tMyInstance;
  
  /* Init local variables */
  u8Status = CLEAR;
  
  /* From this point on, use tMyInstance instead of u8MyInstance */
  tMyInstance.W = u8MyInstanceWCTAR;
  ptMyDSPI = catDSPIInstances[tMyInstance.P.Instance];
  
  /* Make sure there's no on-going transmission before performing any task   */
  if(CLEAR == u8fnIsDSPIBusy(tMyInstance.P.Instance))
  {
    /* Copy arguments to global variables, adjusting accordingly the buffer  */
    /* size to the frame size.                                               */
    if((BITS_IN_BYTE - 1u) < ptMyDSPI->CTAR[tMyInstance.P.CTAR].B.FMSZ)
    {
      gpu16DSPITxBuffer[tMyInstance.P.Instance] = pu16DSPITx;
      gpu16DSPIRxBuffer[tMyInstance.P.Instance] = pu16DSPIRx;
      gau8DSPITransferSize[tMyInstance.P.Instance] = DSPI_FULL_TRANSFER_BITS;
    }
    else
    {
      gpu8DSPITxBuffer[tMyInstance.P.Instance] = (uint8_t*)pu16DSPITx;
      gpu8DSPIRxBuffer[tMyInstance.P.Instance] = (uint8_t*)pu16DSPIRx;
      gau8DSPITransferSize[tMyInstance.P.Instance] = BITS_IN_BYTE;
    }
    gau8DSPIBuffSize[tMyInstance.P.Instance] = u8Size;
    gau8DSPIWordsRx[tMyInstance.P.Instance] = CLEAR;
    
    /* Enable Previuosly configured SPI */
    vfnDSPIEnable(tMyInstance, u8CSEnable, TRUE);
  }
  else
  {
    /* Flag as an issue */
    u8Status = DSPI_BUSY_WITH_PREVIOUS_TX;
  }
  
  return (u8Status);
}

/*
 ******************************************************************************
 * vfnDSPIEnable
 ******************************************************************************
 */
void vfnDSPIEnable(const DSPIInstance_t tMyInstance, const uint8_t u8CSEnable,
                   const uint8_t u8Start)
{
  /* Local variables */
  DSPI_t ptMyDSPI;
  uint32_t u32MyPUSHR;
  
  /* Start by selecting the correct SPI unit */
  ptMyDSPI = catDSPIInstances[tMyInstance.P.Instance];
  
  if(CLEAR != u8Start)
  {
    /* Depending on the state of FIFO, enable or disable interrupts. Take a  */
    /* look at u8fnConfigDSPIGeneral for more info.                          */
    if(TRUE == gau8DSPITxFIFOIsEnabled[tMyInstance.P.Instance])
    {
      /* In this case, FIFO is enabled; TCFRE is disabled */
      ptMyDSPI->RSER.B.TCFRE = CLEAR;
      /* End of Queue must be enabled */
      ptMyDSPI->RSER.B.EOQFRE = TRUE;
    }
    else
    {
      /* In this case, FIFO is disabled, TCF shall be enabled */
      ptMyDSPI->RSER.B.TCFRE = TRUE;
      /* End of Queue must be disabled */
      ptMyDSPI->RSER.B.EOQFRE = CLEAR;
    }

    /* Write everything to a 32-bit variable first since PUSHR likes 32-bit  */
    /* data-transfers only. Include CTAS, u8CSEnable, and data to send.      */
    u32MyPUSHR = (((uint32_t)(tMyInstance.P.CTAR)) << 28);
    u32MyPUSHR |= (((uint32_t)u8CSEnable) << 16);
    
    /* Send the next byte according to the pointer */
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[tMyInstance.P.Instance])
    {
      u32MyPUSHR |= *(gpu16DSPITxBuffer[tMyInstance.P.Instance])++;
    }
    else
    {
      u32MyPUSHR |= *(gpu8DSPITxBuffer[tMyInstance.P.Instance])++;
    }

    /* Decrement counter once */
    gau8DSPIBuffSize[tMyInstance.P.Instance]--;
    
    /* If this is the last word to send, flag an End-of-Queue */
    if(CLEAR == gau8DSPIBuffSize[tMyInstance.P.Instance])
    {
      u32MyPUSHR |= PUSHR_EOQ_MASK;
    }
    else
    {
      /* Nothing */
    }

    ptMyDSPI->PUSHR.R = u32MyPUSHR;
    
    /* Pass to a running mode in the DSPI state-machine. Here because        */
    /* enabling EOQ interrupts will take us directly to that interrupt       */
    ptMyDSPI->MCR.B.HALT = CLEAR;
    
    /* Enable FIFO if this was the proper config and                         */
    /* there's still data to send                                            */
    if(CLEAR != gau8DSPIBuffSize[tMyInstance.P.Instance])
    {
      ptMyDSPI->RSER.B.TFFFRE = gau8DSPITxFIFOIsEnabled[tMyInstance.P.Instance];
      ptMyDSPI->RSER.B.RFDFRE = gau8DSPIRxFIFOIsEnabled[tMyInstance.P.Instance];
    }
    else
    {
      /* Let's try going directly to EOQ interrupt instead */
    }
  }
  else
  {
    /* Pass to a stop mode in the DSPI state-machine */
    ptMyDSPI->MCR.B.HALT = TRUE;
  }
  
  return;
}
/*
 ******************************************************************************
 * u8fnDSPIStatus
 ******************************************************************************
 */
uint32_t u32fnDSPIStatus(uint8_t u8Instance)
{
  return (catDSPIInstances[u8Instance]->SR.R);
}
/*
 ******************************************************************************
 * u8fnConfigDSPIPreset
 ******************************************************************************
 */
uint8_t u8fnConfigDSPIGeneral(const DSPIConfig_t* tDSPIConfig)
{
  uint8_t u8Status;
  DSPI_t ptMyDSPI;
  
  u8Status = CLEAR;
  
  /* Start by selecting the correct SPI unit */
  ptMyDSPI = catDSPIInstances[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance];
  
  /* Only continue if Disable is not set and the instance is halted */
  if((CLEAR == tDSPIConfig->P.Disable) && (TRUE == ptMyDSPI->MCR.B.HALT))
  {
    /* Flush Buffers */
    ptMyDSPI->MCR.B.CLR_TXF = TRUE;
    ptMyDSPI->MCR.B.CLR_RXF = TRUE;
    
    /* Select the Mode */
    ptMyDSPI->MCR.B.MSTR = tDSPIConfig->P.Mode;
    
    /* Enable continuous mode if this is the choice */
    ptMyDSPI->MCR.B.CONT_SCKE = tDSPIConfig->P.ContClock;
    
    /* Enable or disable DSPI FIFO buffers */
    ptMyDSPI->MCR.B.DIS_TXF = tDSPIConfig->P.TxFIFODis;
    ptMyDSPI->MCR.B.DIS_RXF = tDSPIConfig->P.RxFIFODis;
    
    /* Set the CS state when not transmitting */
    ptMyDSPI->MCR.B.PCSIS7 = tDSPIConfig->P.CS7HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS6 = tDSPIConfig->P.CS6HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS5 = tDSPIConfig->P.CS5HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS4 = tDSPIConfig->P.CS4HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS3 = tDSPIConfig->P.CS3HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS2 = tDSPIConfig->P.CS2HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS1 = tDSPIConfig->P.CS1HiWhenInactive;
    ptMyDSPI->MCR.B.PCSIS0 = tDSPIConfig->P.CS0HiWhenInactive;
    
    /* Configure Interrupts/DMA based on FIFO buffer config */
    /* Start with Tx */
    if(CLEAR == tDSPIConfig->P.TxFIFODis)
    {
      /* If FIFO is enabled, flag for future */
      gau8DSPITxFIFOIsEnabled[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance] = TRUE;
      ptMyDSPI->RSER.B.TCFRE = CLEAR;
    }
    else
    {
      /* Use the Tx empty interrupt */
      gau8DSPITxFIFOIsEnabled[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance]
          = CLEAR;
      ptMyDSPI->RSER.B.TFFFRE = CLEAR;
      ptMyDSPI->RSER.B.TCFRE = tDSPIConfig->P.ISRTxEn;
    }

    /* Do the same for Rx - if Rx FIFOs are enabled, use Rx Interrupt */
    if(CLEAR == tDSPIConfig->P.RxFIFODis)
    {
      /* If FIFO is enabled, use the Rx interrupt */
      gau8DSPIRxFIFOIsEnabled[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance] = TRUE;
      ptMyDSPI->RSER.B.RFDFRE = tDSPIConfig->P.ISRRxEn;
      ptMyDSPI->RSER.B.RFOFRE = CLEAR;
    }
    else
    {
      /* Use the Tx full interrupt */
      gau8DSPIRxFIFOIsEnabled[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance]
          = CLEAR;
      ptMyDSPI->RSER.B.RFDFRE = CLEAR;
      ptMyDSPI->RSER.B.RFOFRE = CLEAR;
    }

    /* If FIFO is enabled, use the FIFO interrupt */
    /* Configure DMA as well - it will only play a role if FIFO is enabled */
    ptMyDSPI->RSER.B.TFFFDIRS = tDSPIConfig->P.ISRTxDMAEn;
    ptMyDSPI->RSER.B.RFDFDIRS = tDSPIConfig->P.ISRRxDMAEn;
    
  }
  else
  {
    /* Just flag in status and exit */
    u8Status = DSPI_NOT_HALTED;
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnConfigDSPIPreset
 ******************************************************************************
 */
uint8_t u8fnConfigDSPIPreset(const DSPIPresetConfig_t* tDSPIConfig)
{
  /* Declare local variables */
  uint8_t u8Status;
  DSPI_t ptMyDSPI;
  
  /* Init local variables */
  u8Status = CLEAR;
  
  /* Start by selecting the correct SPI unit */
  ptMyDSPI = catDSPIInstances[(uint8_t)tDSPIConfig->P.MyDSPI.P.Instance];
  
  /* Now we can configure accordingly */
  /* Start by setting baud rate settings */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.DBR
      = tDSPIConfig->P.BaudRateDoubler;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.PBR
      = tDSPIConfig->P.BaudRatePrescaler;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.BR = tDSPIConfig->P.BaudRate;
  
  /* Polarity and phase */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.CPHA = tDSPIConfig->P.CPhase;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.CPOL = tDSPIConfig->P.CPol;
  
  /* Determine the delay after CS goes down */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.CSSCK = tDSPIConfig->P.CSSCK;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.PCSSCK = tDSPIConfig->P.PCSSCK;
  
  /* Determine the order (LSB first/ MSB first */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.LSBFE
      = tDSPIConfig->P.LSBFirst;
  
  /* Set Frame Size */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.FMSZ
      = tDSPIConfig->P.FrameSize;
  
  /* Delay between CS transfers is hard-coded below */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.DT
      = tDSPIConfig->P.DelayAfterTransfer; //DSPI_DELAY_POST_TRANSFER;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.PDT
      = tDSPIConfig->P.DelayAfterTransferPrescaler; //DSPI_PDT_DEFAULT;

  /* Delay between last clock and CS going high is hard-coded here */
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.ASC
      = tDSPIConfig->P.LagAfterLastClk;// DSPI_DELAY_AFTER_SCK;
  ptMyDSPI->CTAR[tDSPIConfig->P.MyDSPI.P.CTAR].B.PASC
      = tDSPIConfig->P.LagAfterLastClkPrescaler;// DSPI_PRESCALER_AFTER_SCK;

  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnReadBackDSPIInstance
 ******************************************************************************
 */
static uint8_t u8fnReadBackDSPIInstance(DSPI_t ptMyDSPI)
{
  uint8_t u8Instance;
  
  switch((uint32_t)ptMyDSPI)
  {
    case ((uint32_t)&DSPI_3):
    {
      u8Instance = 3;
      break;
    }
    case ((uint32_t)&DSPI_2):
    {
      u8Instance = 2;
      break;
    }
    case ((uint32_t)&DSPI_1):
    {
      u8Instance = 1;
      break;
    }
    case ((uint32_t)&DSPI_0):
    {
      u8Instance = CLEAR;
      break;
    }
  }; /* End switch-case */
  
  return (u8Instance);
}
/*
 ******************************************************************************
 * vfnGenericDSPIFUFISR
 ******************************************************************************
 */
uint8_t u8fnIsDSPIBusy(uint8_t u8Instance)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init local variables */
  u8Status = DSPI_STATUS_CLEAR;
  
  /* Is the DSPI SM running ? */
  if(CLEAR == catDSPIInstances[u8Instance]->MCR.B.HALT)
  {
    u8Status = DSPI_BUSY_WITH_PREVIOUS_TX;
  }
  else
  {
    /* We can configure */
  }
  return (u8Status);
}
/*
 ******************************************************************************
 * u32fnFormatDSPIPUSHR
 ******************************************************************************
 */
uint32_t u32fnFormatDSPIPUSHR(uint8_t u8DSPIInstanceWCTAR, uint8_t u8CS,
                              uint8_t u8ContCS, uint8_t u8EndOfQueueFlag,
                              uint16_t u16Msg)
{
  return ((uint32_t)u16Msg | (uint32_t)(u8CS << 16u) | 
      (uint32_t)((u8DSPIInstanceWCTAR & 0x0Fu) << 28u) | 
      (uint32_t)(u8ContCS << 31u) | 
      (uint32_t)((u8EndOfQueueFlag & 0x01) << 27u));
}
/*
 ******************************************************************************
 * u8fnDSPISwitchIsrMode
 ******************************************************************************
 */
uint8_t u8fnDSPISwitchIsrMode(uint8_t u8DSPIInstanceWCTAR, uint8_t u8IsrMode)
{
  /* Locals */
  uint8_t u8Status;
  DSPI_t tMyDSPI;
  
  /* Init variables */
  u8Status = CLEAR;
  tMyDSPI = catDSPIInstances[u8DSPIInstanceWCTAR >> 4u];
  
  /* Whatever we're doing, we're stopping right now. */
  tMyDSPI->MCR.B.HALT = TRUE;
  
  /* Switch modes according to u8IsrMode */
  tMyDSPI->RSER.B.TFFFDIRS = (u8IsrMode & BIT0);
  tMyDSPI->RSER.B.RFDFDIRS = (u8IsrMode & BIT0);
  
  /* Also, if DMA is enable, the general enable bit for the SPI should be on */
  tMyDSPI->MCR.B.HALT = !(u8IsrMode & BIT0);
  
  /* Make sure TFFF is enabled in order to trigger a DMA transfer */
  DSPI_0.RSER.B.TFFFRE = (u8IsrMode & BIT0);
  
  return (u8Status);
}
/*
 ******************************************************************************
 * vfnGenericDSPIFUFISR
 ******************************************************************************
 */
static void vfnGenericDSPIFUFISR(DSPI_t tpActiveDSPI)
{
  /* Nothing - Device always configured as Master */
  (void)tpActiveDSPI;
  return;
}
/*
 ******************************************************************************
 * vfnDSPI0FUFISR
 ******************************************************************************
 */
void vfnDSPI0FUFISR(void)
{
  vfnGenericDSPIFUFISR(&DSPI_0);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI1FUFISR
 ******************************************************************************
 */
void vfnDSPI1FUFISR(void)
{
  vfnGenericDSPIFUFISR(&DSPI_1);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI2FUFISR
 ******************************************************************************
 */
void vfnDSPI2FUFISR(void)
{
  vfnGenericDSPIFUFISR(&DSPI_2);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI3FUFISR
 ******************************************************************************
 */
void vfnDSPI3FUFISR(void)
{
  vfnGenericDSPIFUFISR(&DSPI_3);
  return;
}
/*
 ******************************************************************************
 * vfnGenericDSPITCFIsr
 ******************************************************************************
 */
static void vfnGenericDSPITCFIsr(uint8_t u8Instance)
{
  /* Local variables */
  DSPI_t ptMyDSPI;
  
  /* Make the DSPI instance explicit */
  ptMyDSPI = catDSPIInstances[u8Instance];
  
  /* Is this the last time we come in here? */
  if(CLEAR == gau8DSPIBuffSize[u8Instance])
  {
    /* Disable future interrupts */
    ptMyDSPI->RSER.B.TCFRE = CLEAR;
    
    /* Read-back reception accordingly */
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[u8Instance])
    {
      *gpu16DSPIRxBuffer[u8Instance] = (uint16_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu16DSPIRxBuffer[u8Instance])++;
    }
    else
    {
      *gpu8DSPIRxBuffer[u8Instance] = (uint8_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu8DSPIRxBuffer[u8Instance])++;
    }
  }
  else
  {
    /* Place next byte in buffer depending on what format we're using */
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[u8Instance])
    {
      ptMyDSPI->PUSHR.B.TXDATA = *gpu16DSPITxBuffer[u8Instance];
      /* Read incoming byte in buffer */
      *gpu16DSPIRxBuffer[u8Instance] = (uint16_t)ptMyDSPI->POPR.B.RXDATA;
      
      (gpu16DSPITxBuffer[u8Instance])++;
      (gpu16DSPIRxBuffer[u8Instance])++;
    }
    else
    {
      ptMyDSPI->PUSHR.B.TXDATA = *gpu8DSPITxBuffer[u8Instance];
      /* Read incoming byte in buffer */
      *gpu8DSPIRxBuffer[u8Instance] = (uint8_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu8DSPITxBuffer[u8Instance])++;
      (gpu8DSPIRxBuffer[u8Instance])++;
    } /* End else */
    
    /* Decrement Tx Buffer Size */
    gau8DSPIBuffSize[u8Instance]--;
  } /* End else */
  
  /* Increment Rx Buffer Size */
  gau8DSPIWordsRx[u8Instance]++;
  
  /* Clear existing flag by writing to it - also clears the receive flag */
  ptMyDSPI->SR.B.TCF = TRUE;
  
  return;
}
/*
 ******************************************************************************
 * vfnDSPI0TCFIsr
 ******************************************************************************
 */
void vfnDSPI0TCFIsr(void)
{
  vfnGenericDSPITCFIsr(0u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI1TCFIsr
 ******************************************************************************
 */
void vfnDSPI1TCFIsr(void)
{
  vfnGenericDSPITCFIsr(1u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI2TCFIsr
 ******************************************************************************
 */
void vfnDSPI2TCFIsr(void)
{
  vfnGenericDSPITCFIsr(2u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI3TCFIsr
 ******************************************************************************
 */
void vfnDSPI3TCFIsr(void)
{
  vfnGenericDSPITCFIsr(3u);
  return;
}
/*
 ******************************************************************************
 * vfnGenericDSPIRFDFIsr
 * This interrupt is entered when FIFOs are enabled and data can be read.
 ******************************************************************************
 */
static void vfnGenericDSPIRFDFIsr(uint8_t u8Instance)
{
  /* Local variables */
  DSPI_t ptMyDSPI;
  
  /* Make the DSPI instance explicit */
  ptMyDSPI = catDSPIInstances[u8Instance];
  
  if(CLEAR != ptMyDSPI->SR.B.RFDF)
  {
    
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[u8Instance])
    {
      *gpu16DSPIRxBuffer[u8Instance] = (uint16_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu16DSPIRxBuffer[u8Instance])++;
      gau8DSPIWordsRx[u8Instance]++;
    }
    else
    {
      *gpu8DSPIRxBuffer[u8Instance] = (uint8_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu8DSPIRxBuffer[u8Instance])++;
      gau8DSPIWordsRx[u8Instance]++;
    }
  }
  else
  {
    /* Just leave */
  }
  ptMyDSPI->SR.B.RFDF = TRUE;
  return;
}
/*
 ******************************************************************************
 * vfnDSPI0RFDFIsr
 ******************************************************************************
 */
void vfnDSPI0RFDFIsr(void)
{
  vfnGenericDSPIRFDFIsr(0u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI1RFDFIsr
 ******************************************************************************
 */
void vfnDSPI1RFDFIsr(void)
{
  vfnGenericDSPIRFDFIsr(1u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI2RFDFIsr
 ******************************************************************************
 */
void vfnDSPI2RFDFIsr(void)
{
  vfnGenericDSPIRFDFIsr(2u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI3RFDFIsr
 ******************************************************************************
 */
void vfnDSPI3RFDFIsr(void)
{
  vfnGenericDSPIRFDFIsr(3u);
  return;
}
/*
 ******************************************************************************
 * vfnGenericDSPIEOQIsr
 ******************************************************************************
 */
static void vfnGenericDSPIEOQIsr(uint8_t u8Instance)
{
  /* Local variables */
  DSPI_t ptMyDSPI;
  DSPIInstance_t tInstance;
  
  /* Make the DSPI instance explicit */
  ptMyDSPI = catDSPIInstances[u8Instance];
  tInstance.P.Instance = u8Instance;
  
  /* If there still data in the receive buffer, read it */
  if(TRUE == ptMyDSPI->SR.B.RFDF)
  {
    do
    {
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[u8Instance])
    {
      *gpu16DSPIRxBuffer[u8Instance] = (uint16_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu16DSPIRxBuffer[u8Instance])++;
      gau8DSPIWordsRx[tInstance.P.Instance]++;
    }
    else
    {
      *gpu8DSPIRxBuffer[u8Instance] = (uint8_t)ptMyDSPI->POPR.B.RXDATA;
      (gpu8DSPIRxBuffer[u8Instance])++;
      gau8DSPIWordsRx[u8Instance]++;
    }
  }while(CLEAR < ptMyDSPI->SR.B.RXCTR);
}
else
{
  /* Don't read anything */
}

/* Disable DSPI */
vfnDSPIEnable(tInstance, TRUE, CLEAR);

/* Clear existing flag by writing to it */
ptMyDSPI->SR.B.EOQF = TRUE;

return;
}
/*
 ******************************************************************************
 * vfnDSPI0TCFIsr
 ******************************************************************************
 */
void vfnDSPI0EOQIsr(void)
{
  vfnGenericDSPIEOQIsr(0);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI1TCFIsr
 ******************************************************************************
 */
void vfnDSPI1EOQIsr(void)
{
  vfnGenericDSPIEOQIsr(1);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI2TCFIsr
 ******************************************************************************
 */
void vfnDSPI2EOQIsr(void)
{
  vfnGenericDSPIEOQIsr(2);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI3TCFIsr
 ******************************************************************************
 */
void vfnDSPI3EOQIsr(void)
{
  vfnGenericDSPIEOQIsr(3);
  return;
}
/*
 ******************************************************************************
 * vfnGenericDSPITFFFIsr
 * This interrupt is taken if FIFO buffer is enabled.
 ******************************************************************************
 */
static void vfnGenericDSPITFFFIsr(uint8_t u8Instance)
{
  /* Local variables */
  DSPI_t ptMyDSPI;
  uint8_t u8NoMoreDataToTx;
  uint32_t u32LocalPUSHR;
  
  /* Init local variables */
  u8NoMoreDataToTx = CLEAR;
  
  /* Remember: PUSHR register only likes 32-bit words written to it. If      */
  /* a register is addressed directly, the compiled instructions write the   */
  /* whole register, essentially starting a new SPI transfer. That is why we */
  /* use u32LocalPUSHR - to construct what we want to send before sending it */
  u32LocalPUSHR = CLEAR;
  
  /* Make the DSPI instance explicit */
  ptMyDSPI = catDSPIInstances[u8Instance];
  
  /* Clear existing flag by writing to it - also clears the receive flag */
  ptMyDSPI->SR.B.TFFF = TRUE;
  
  /* Loop while there's data or the DSPI buffer has still some space left */
  if(DSPI_FIFO_BUFFER_DEPTH > ptMyDSPI->SR.B.TXCTR)
  {
    if(CLEAR == --gau8DSPIBuffSize[u8Instance])
    {
      u8NoMoreDataToTx = TRUE;
      ptMyDSPI->RSER.B.TFFFRE = CLEAR;
      
    }
    else
    {
      u8NoMoreDataToTx = CLEAR;
      ptMyDSPI->RSER.B.TFFFRE = TRUE;
    }

    /* Place next byte in local buffer depending on what format we're using */
    if(DSPI_FULL_TRANSFER_BITS == gau8DSPITransferSize[u8Instance])
    {
      u32LocalPUSHR = *gpu16DSPITxBuffer[u8Instance];
      (gpu16DSPITxBuffer[u8Instance])++;
    }
    else
    {
      u32LocalPUSHR = *gpu8DSPITxBuffer[u8Instance];
      (gpu8DSPITxBuffer[u8Instance])++;
    }

    /* Place the EOQ value according to this being the last word or not */
    u32LocalPUSHR |= (u8NoMoreDataToTx << 27u);
    u32LocalPUSHR |= (ptMyDSPI->PUSHR.R & 0xF7FF0000u);
    
    /* Write to the SPI */
    ptMyDSPI->PUSHR.R = u32LocalPUSHR;
  }
  else
  {
    /* Exit */
  }
  return;
}
/*
 ******************************************************************************
 * vfnDSPI0TCFIsr
 ******************************************************************************
 */
void vfnDSPI0TFFFIsr(void)
{
  vfnGenericDSPITFFFIsr(0u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI1TFFFIsr
 ******************************************************************************
 */
void vfnDSPI1TFFFIsr(void)
{
  vfnGenericDSPITFFFIsr(1u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI2TFFFIsr
 ******************************************************************************
 */
void vfnDSPI2TFFFIsr(void)
{
  vfnGenericDSPITFFFIsr(2u);
  return;
}
/*
 ******************************************************************************
 * vfnDSPI3TFFFIsr
 ******************************************************************************
 */
void vfnDSPI3TFFFIsr(void)
{
  vfnGenericDSPITFFFIsr(3u);
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */